package com.cgt.xiaotao.product.service.impl;

import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.baomidou.mybatisplus.core.metadata.OrderItem;
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import com.baomidou.mybatisplus.extension.plugins.pagination.PageDTO;
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import com.cgt.xiaotao.product.domain.po.Product;
import com.cgt.xiaotao.product.domain.query.ProductPageQuery;
import com.cgt.xiaotao.product.domain.vo.ProductListVO;
import com.cgt.xiaotao.product.mapper.ProductMapper;
import com.cgt.xiaotao.product.service.ISearchService;
import lombok.RequiredArgsConstructor;
import org.springframework.stereotype.Service;
import org.springframework.util.StringUtils;

import java.util.List;
import java.util.stream.Collectors;

@Service
@RequiredArgsConstructor
public class SearchServiceImpl extends ServiceImpl<ProductMapper, Product> implements ISearchService {

    private final ProductMapper productMapper;

    @Override
    public PageDTO<ProductListVO> selectPageByCondition(ProductPageQuery query) {
        // 创建分页对象，支持排序
        Page<Product> page = new Page<>(query.getPageNo(), query.getPageSize());

        // 如果前端传了sortBy字段，则按sortBy字段排序
        if (StringUtils.hasText(query.getSortBy())) {
            if (query.getSortBy().equalsIgnoreCase("price")) {
                // 价格排序
                if (Boolean.TRUE.equals(query.getIsAsc())) {
                    page.addOrder(new OrderItem("price", true));
                } else {
                    page.addOrder(new OrderItem("price", false));
                }
            } else if (query.getSortBy().equalsIgnoreCase("sales")) {
                // 销量排序
                if (Boolean.TRUE.equals(query.getIsAsc())) {
                    page.addOrder(new OrderItem("sales", true));
                } else {
                    page.addOrder(new OrderItem("sales", false));
                }
            } else if (query.getSortBy().equalsIgnoreCase("comments")) {
                // 评论数排序
                if (Boolean.TRUE.equals(query.getIsAsc())) {
                    page.addOrder(new OrderItem("comments", true));
                } else {
                    page.addOrder(new OrderItem("comments", false));
                }
            } else if (query.getSortBy().equalsIgnoreCase("createTime")) {
                // 创建时间排序
                if (Boolean.TRUE.equals(query.getIsAsc())) {
                    page.addOrder(new OrderItem("create_time", true));
                } else {
                    page.addOrder(new OrderItem("create_time", false));
                }
            }
            // 默认按ID排序
            else {
                page.addOrder(new OrderItem("id", false)); // 默认按ID降序
            }
        }
        // 如果没有指定排序字段，默认按创建时间降序排列
        else {
            page.addOrder(new OrderItem("create_time", false));
        }

        // 构建查询条件
        LambdaQueryWrapper<Product> wrapper = new LambdaQueryWrapper<>();

        // 商品名称模糊查询
        if (StringUtils.hasText(query.getName())) {
            wrapper.like(Product::getName, query.getName());
        }

        // 价格区间查询
        if (query.getMinPrice() != null) {
            wrapper.ge(Product::getPrice, query.getMinPrice());
        }
        if (query.getMaxPrice() != null) {
            wrapper.le(Product::getPrice, query.getMaxPrice());
        }

        // 标签查询 - 支持多个标签
        if (query.getTags() != null && !query.getTags().isEmpty()) {
            for (String tag : query.getTags()) {
                if (StringUtils.hasText(tag)) {
                    wrapper.like(Product::getTags, tag);
                }
            }
        }

        // 执行分页查询
        page = this.page(page, wrapper);

        // 转换为VO对象
        PageDTO<ProductListVO> result = new PageDTO<>();
        result.setRecords(page.getRecords().stream()
                .map(product -> new ProductListVO(
                        product.getId(),
                        product.getImageUrl(),
                        product.getName(),
                        product.getPrice(),
                        product.getSales(),
                        product.getComments(),
                        product.getIsAd()
                )).collect(Collectors.toList()));
        result.setTotal(page.getTotal());
        result.setCurrent(page.getCurrent());
        result.setSize(page.getSize());
        result.setPages(page.getPages());

        return result;
    }

    //根据关键字搜索商品名称建议
    @Override
    public String[] getSuggest(String keyword) {
        if (!StringUtils.hasText(keyword)) {
            return new String[0];
        }

        // 为了避免性能问题，关键字长度至少为2才提供搜索建议
        if (keyword.length() < 2) {
            return new String[0];
        }

        // 使用商品名称进行模糊查询，获取前10个不重复的建议
        LambdaQueryWrapper<Product> wrapper = new LambdaQueryWrapper<>();
        wrapper.like(Product::getName, keyword)
                .select(Product::getName)
                .groupBy(Product::getName) // 按名称分组去重
                .last("LIMIT 10");

        List<Product> products = this.list(wrapper);

        return products.stream()
                .map(Product::getName)
                .toArray(String[]::new);
    }

}

